package com.yilian.io;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

/**
 * Java IO流练习类
 * 
 * 这个类包含了各种实际应用场景的IO练习，展示了IO在实际开发中的用途：
 * 1. 配置文件处理 - 读写配置文件
 * 2. 日志记录器 - 实现简单的日志系统
 * 3. 数据导入导出 - CSV格式的数据处理
 * 4. 文件压缩工具 - ZIP文件的压缩和解压
 * 5. 批量文件处理 - 批量重命名和移动文件
 * 6. 网络数据模拟 - 模拟网络数据传输
 * 
 * 学习要点：
 * - 这些练习展示了IO在实际项目中的应用
 * - 每个练习都包含了完整的实现逻辑和异常处理
 * - 这些工具类可以扩展为通用的框架组件
 * - 理解这些应用有助于掌握IO的高级用法
 * 
 * @author 练习项目
 * @version 1.0
 */
public class IOPractice {
    
    // 工作目录，用于存放测试文件
    private static final String WORK_DIR = "io_practice_files";
    
    /**
     * 主方法 - 程序入口点
     * 依次执行各种IO应用练习
     * 
     * @param args 命令行参数（未使用）
     */
    public static void main(String[] args) {
        System.out.println("=== Java IO流练习 ===\n");
        
        // 创建测试目录
        createTestDirectory();
        
        // 练习1：配置文件处理
        practiceConfigFileHandler();
        
        // 练习2：日志记录器
        practiceLogger();
        
        // 练习3：数据导入导出
        practiceDataImportExport();
        
        // 练习4：文件压缩工具
        practiceFileCompression();
        
        // 练习5：批量文件处理
        practiceBatchFileProcessing();
        
        // 练习6：网络数据模拟
        practiceNetworkDataSimulation();
        
        System.out.println("\n=== IO流练习完成 ===");
    }
    
    /**
     * 创建测试目录
     * 用于存放各种测试文件
     */
    private static void createTestDirectory() {
        try {
            Path workDir = Paths.get(WORK_DIR);
            if (!Files.exists(workDir)) {
                Files.createDirectories(workDir);
                System.out.println("创建测试目录: " + workDir.toAbsolutePath());
            }
        } catch (IOException e) {
            System.err.println("创建测试目录失败: " + e.getMessage());
        }
    }
    
    /**
     * 练习1：配置文件处理
     * 
     * 实现一个简单的配置文件处理器，支持：
     * - 读取配置文件
     * - 写入配置文件
     * - 配置项的增加、修改、删除
     * - 配置文件的备份和恢复
     * 
     * 应用场景：
     * - 应用程序配置管理
     * - 系统参数设置
     * - 用户偏好配置
     */
    public static void practiceConfigFileHandler() {
        System.out.println("练习1: 配置文件处理");
        System.out.println("----------------------------------------");
        
        String configFile = WORK_DIR + "/app_config.properties";
        
        try {
            // 创建配置管理器
            ConfigManager configManager = new ConfigManager(configFile);
            
            // 设置一些配置项
            configManager.setProperty("app.name", "IO练习应用");
            configManager.setProperty("app.version", "1.0.0");
            configManager.setProperty("database.url", "jdbc:mysql://localhost:3306/test");
            configManager.setProperty("database.username", "admin");
            configManager.setProperty("database.password", "123456");
            configManager.setProperty("log.level", "INFO");
            configManager.setProperty("cache.enabled", "true");
            configManager.setProperty("cache.size", "1000");
            
            // 保存配置到文件
            configManager.saveConfig();
            System.out.println("配置文件已保存: " + configFile);
            
            // 读取配置文件
            System.out.println("读取配置文件内容:");
            Properties loadedProps = configManager.loadConfig();
            for (String key : loadedProps.stringPropertyNames()) {
                System.out.println("  " + key + " = " + loadedProps.getProperty(key));
            }
            
            // 修改配置项
            configManager.setProperty("log.level", "DEBUG");
            configManager.setProperty("cache.size", "2000");
            configManager.saveConfig();
            System.out.println("配置项已更新");
            
            // 备份配置文件
            String backupFile = WORK_DIR + "/app_config_backup.properties";
            configManager.backupConfig(backupFile);
            System.out.println("配置文件已备份到: " + backupFile);
            
        } catch (IOException e) {
            System.err.println("配置文件处理失败: " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println();
    }
    
    /**
     * 练习2：日志记录器
     * 
     * 实现一个简单的日志记录器，支持：
     * - 不同级别的日志记录
     * - 日志文件轮转
     * - 日志格式化
     * - 控制台和文件双重输出
     * 
     * 应用场景：
     * - 应用程序日志记录
     * - 错误追踪和调试
     * - 系统监控和审计
     */
    public static void practiceLogger() {
        System.out.println("练习2: 日志记录器");
        System.out.println("----------------------------------------");
        
        String logFile = WORK_DIR + "/app.log";
        
        try {
            // 创建日志记录器
            SimpleLogger logger = new SimpleLogger(logFile);
            
            // 记录不同级别的日志
            logger.info("应用程序启动");
            logger.debug("调试信息：配置加载完成");
            logger.warn("警告：数据库连接池使用率较高");
            logger.error("错误：无法连接到远程服务");
            logger.info("用户登录：用户名=admin");
            logger.debug("调试信息：用户权限验证通过");
            logger.info("应用程序关闭");
            
            // 显示日志文件内容
            System.out.println("日志文件内容:");
            try (BufferedReader br = new BufferedReader(new FileReader(logFile, StandardCharsets.UTF_8))) {
                String line;
                while ((line = br.readLine()) != null) {
                    System.out.println("  " + line);
                }
            }
            
            // 创建新的日志文件（模拟日志轮转）
            String newLogFile = WORK_DIR + "/app_new.log";
            SimpleLogger newLogger = new SimpleLogger(newLogFile);
            newLogger.info("新的日志文件开始记录");
            newLogger.info("系统重启完成");
            
        } catch (IOException e) {
            System.err.println("日志记录失败: " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println();
    }
    
    /**
     * 练习3：数据导入导出
     * 
     * 实现CSV格式的数据导入导出功能，支持：
     * - 将对象列表导出为CSV文件
     * - 从CSV文件导入数据到对象列表
     * - 支持中文和特殊字符
     * - 数据验证和错误处理
     * 
     * 应用场景：
     * - 数据迁移和备份
     * - 报表生成
     * - 数据交换
     * - 批量数据处理
     */
    public static void practiceDataImportExport() {
        System.out.println("练习3: 数据导入导出");
        System.out.println("----------------------------------------");
        
        String csvFile = WORK_DIR + "/students.csv";
        
        try {
            // 创建学生数据
            List<Student> students = new ArrayList<>();
            students.add(new Student("2021001", "张三", 20, "计算机科学", 
                                   java.time.LocalDate.of(2021, 9, 1), 3.8));
            students.add(new Student("2021002", "李四", 21, "软件工程", 
                                   java.time.LocalDate.of(2021, 9, 1), 3.6));
            students.add(new Student("2021003", "王五", 22, "数据科学", 
                                   java.time.LocalDate.of(2021, 9, 1), 3.9));
            students.add(new Student("2021004", "赵六", 20, "人工智能", 
                                   java.time.LocalDate.of(2021, 9, 1), 3.7));
            
            // 导出为CSV文件
            CSVExporter exporter = new CSVExporter();
            exporter.exportStudents(students, csvFile);
            System.out.println("学生数据已导出到CSV文件: " + csvFile);
            
            // 显示CSV文件内容
            System.out.println("CSV文件内容:");
            try (BufferedReader br = new BufferedReader(new FileReader(csvFile, StandardCharsets.UTF_8))) {
                String line;
                while ((line = br.readLine()) != null) {
                    System.out.println("  " + line);
                }
            }
            
            // 从CSV文件导入数据
            CSVImporter importer = new CSVImporter();
            List<Student> importedStudents = importer.importStudents(csvFile);
            System.out.println("从CSV文件导入的学生数据:");
            for (Student student : importedStudents) {
                System.out.println("  " + student.getSummary());
            }
            
        } catch (IOException e) {
            System.err.println("数据导入导出失败: " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println();
    }
    
    /**
     * 练习4：文件压缩工具
     * 
     * 实现ZIP文件的压缩和解压功能，支持：
     * - 单个文件压缩
     * - 目录压缩
     * - 文件解压
     * - 压缩文件内容查看
     * 
     * 应用场景：
     * - 文件备份和归档
     * - 文件传输
     * - 软件包分发
     * - 数据压缩存储
     */
    public static void practiceFileCompression() {
        System.out.println("练习4: 文件压缩工具");
        System.out.println("----------------------------------------");
        
        try {
            // 创建一些测试文件
            createTestFilesForCompression();
            
            // 压缩单个文件
            String sourceFile = WORK_DIR + "/test1.txt";
            String zipFile = WORK_DIR + "/single_file.zip";
            ZipCompressor.compressFile(sourceFile, zipFile);
            System.out.println("单个文件压缩完成: " + zipFile);
            
            // 压缩目录
            String sourceDir = WORK_DIR + "/test_dir";
            String dirZipFile = WORK_DIR + "/directory.zip";
            ZipCompressor.compressDirectory(sourceDir, dirZipFile);
            System.out.println("目录压缩完成: " + dirZipFile);
            
            // 查看压缩文件内容
            System.out.println("压缩文件内容:");
            ZipCompressor.listZipContents(dirZipFile);
            
            // 解压文件
            String extractDir = WORK_DIR + "/extracted";
            ZipCompressor.extractZip(dirZipFile, extractDir);
            System.out.println("文件解压完成到: " + extractDir);
            
        } catch (IOException e) {
            System.err.println("文件压缩操作失败: " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println();
    }
    
    /**
     * 创建用于压缩测试的文件
     */
    private static void createTestFilesForCompression() throws IOException {
        // 创建测试目录
        Path testDir = Paths.get(WORK_DIR, "test_dir");
        if (!Files.exists(testDir)) {
            Files.createDirectories(testDir);
        }
        
        // 创建测试文件
        List<String> lines = Arrays.asList(
            "这是测试文件1",
            "用于演示文件压缩功能",
            "包含中文和English内容"
        );
        Files.write(testDir.resolve("test1.txt"), lines, StandardCharsets.UTF_8);
        
        lines = Arrays.asList(
            "这是测试文件2",
            "包含更多内容",
            "用于测试目录压缩"
        );
        Files.write(testDir.resolve("test2.txt"), lines, StandardCharsets.UTF_8);
        
        // 创建子目录
        Path subDir = testDir.resolve("sub_dir");
        if (!Files.exists(subDir)) {
            Files.createDirectories(subDir);
        }
        
        lines = Arrays.asList(
            "这是子目录中的文件",
            "测试嵌套目录压缩"
        );
        Files.write(subDir.resolve("sub_file.txt"), lines, StandardCharsets.UTF_8);
    }
    
    /**
     * 练习5：批量文件处理
     * 
     * 实现批量文件处理功能，支持：
     * - 批量文件重命名
     * - 批量文件移动
     * - 文件过滤和搜索
     * - 批量内容替换
     * 
     * 应用场景：
     * - 文件整理和归档
     * - 批量数据处理
     * - 文件系统维护
     * - 自动化脚本
     */
    public static void practiceBatchFileProcessing() {
        System.out.println("练习5: 批量文件处理");
        System.out.println("----------------------------------------");
        
        try {
            // 创建一些测试文件
            createTestFilesForBatchProcessing();
            
            // 批量文件重命名
            String sourceDir = WORK_DIR + "/batch_test";
            BatchFileProcessor.renameFiles(sourceDir, "old_", "new_");
            System.out.println("批量重命名完成");
            
            // 批量文件移动
            String targetDir = WORK_DIR + "/batch_moved";
            BatchFileProcessor.moveFiles(sourceDir, targetDir, "*.txt");
            System.out.println("批量移动完成");
            
            // 批量内容替换
            BatchFileProcessor.replaceContent(targetDir, "old", "new");
            System.out.println("批量内容替换完成");
            
            // 显示处理结果
            System.out.println("处理后的文件:");
            Files.walk(Paths.get(targetDir))
                 .filter(Files::isRegularFile)
                 .forEach(path -> {
                     try {
                         System.out.println("  文件: " + path.getFileName() + 
                                          " (大小: " + Files.size(path) + " 字节)");
                     } catch (IOException e) {
                         System.err.println("获取文件大小失败: " + e.getMessage());
                     }
                 });
            
        } catch (IOException e) {
            System.err.println("批量文件处理失败: " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println();
    }
    
    /**
     * 创建用于批量处理测试的文件
     */
    private static void createTestFilesForBatchProcessing() throws IOException {
        Path testDir = Paths.get(WORK_DIR, "batch_test");
        if (!Files.exists(testDir)) {
            Files.createDirectories(testDir);
        }
        
        // 创建测试文件
        for (int i = 1; i <= 5; i++) {
            List<String> lines = Arrays.asList(
                "这是第" + i + "个测试文件",
                "文件名: old_file_" + i + ".txt",
                "内容包含old关键词",
                "用于测试批量处理功能"
            );
            Files.write(testDir.resolve("old_file_" + i + ".txt"), lines, StandardCharsets.UTF_8);
        }
    }
    
    /**
     * 练习6：网络数据模拟
     * 
     * 模拟网络数据传输场景，包括：
     * - 数据包的序列化和反序列化
     * - 数据流的读写
     * - 网络协议模拟
     * - 数据传输错误处理
     * 
     * 应用场景：
     * - 网络编程学习
     * - 协议实现测试
     * - 数据传输模拟
     * - 网络应用开发
     */
    public static void practiceNetworkDataSimulation() {
        System.out.println("练习6: 网络数据模拟");
        System.out.println("----------------------------------------");
        
        try {
            // 创建网络数据包
            NetworkPacket packet = new NetworkPacket();
            packet.setId(1001);
            packet.setType("DATA");
            packet.setPayload("Hello Network World!");
            packet.setTimestamp(System.currentTimeMillis());
            
            // 序列化数据包
            String packetFile = WORK_DIR + "/network_packet.dat";
            NetworkDataSerializer.serializePacket(packet, packetFile);
            System.out.println("网络数据包已序列化到文件: " + packetFile);
            
            // 反序列化数据包
            NetworkPacket loadedPacket = NetworkDataSerializer.deserializePacket(packetFile);
            System.out.println("反序列化的数据包:");
            System.out.println("  ID: " + loadedPacket.getId());
            System.out.println("  类型: " + loadedPacket.getType());
            System.out.println("  负载: " + loadedPacket.getPayload());
            System.out.println("  时间戳: " + loadedPacket.getTimestamp());
            
            // 模拟数据传输
            NetworkDataSimulator simulator = new NetworkDataSimulator();
            simulator.simulateDataTransfer(packet);
            
        } catch (IOException | ClassNotFoundException e) {
            System.err.println("网络数据模拟失败: " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println();
    }
}

// ==================== 配置管理器类 ====================

/**
 * 配置管理器类
 * 负责配置文件的读写和管理
 */
class ConfigManager {
    private final String configFile;
    private final Properties properties;
    
    public ConfigManager(String configFile) {
        this.configFile = configFile;
        this.properties = new Properties();
    }
    
    /**
     * 设置配置项
     */
    public void setProperty(String key, String value) {
        properties.setProperty(key, value);
    }
    
    /**
     * 获取配置项
     */
    public String getProperty(String key) {
        return properties.getProperty(key);
    }
    
    /**
     * 保存配置到文件
     */
    public void saveConfig() throws IOException {
        try (FileOutputStream fos = new FileOutputStream(configFile)) {
            properties.store(fos, "应用程序配置文件 - " + new Date());
        }
    }
    
    /**
     * 从文件加载配置
     */
    public Properties loadConfig() throws IOException {
        try (FileInputStream fis = new FileInputStream(configFile)) {
            properties.load(fis);
        }
        return properties;
    }
    
    /**
     * 备份配置文件
     */
    public void backupConfig(String backupFile) throws IOException {
        try (FileInputStream fis = new FileInputStream(configFile);
             FileOutputStream fos = new FileOutputStream(backupFile)) {
            
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        }
    }
}

// ==================== 简单日志记录器类 ====================

/**
 * 简单日志记录器类
 * 实现基本的日志记录功能
 */
class SimpleLogger {
    private final String logFile;
    private final DateTimeFormatter formatter;
    
    public SimpleLogger(String logFile) {
        this.logFile = logFile;
        this.formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    }
    
    /**
     * 记录信息级别日志
     */
    public void info(String message) throws IOException {
        log("INFO", message);
    }
    
    /**
     * 记录调试级别日志
     */
    public void debug(String message) throws IOException {
        log("DEBUG", message);
    }
    
    /**
     * 记录警告级别日志
     */
    public void warn(String message) throws IOException {
        log("WARN", message);
    }
    
    /**
     * 记录错误级别日志
     */
    public void error(String message) throws IOException {
        log("ERROR", message);
    }
    
    /**
     * 记录日志的核心方法
     */
    private void log(String level, String message) throws IOException {
        String timestamp = LocalDateTime.now().format(formatter);
        String logEntry = String.format("[%s] %s: %s%n", timestamp, level, message);
        
        // 写入文件
        Files.write(Paths.get(logFile), logEntry.getBytes(StandardCharsets.UTF_8), 
                   StandardOpenOption.CREATE, StandardOpenOption.APPEND);
        
        // 同时输出到控制台
        System.out.print(logEntry);
    }
}

// ==================== CSV导出器类 ====================

/**
 * CSV导出器类
 * 负责将学生数据导出为CSV格式
 */
class CSVExporter {
    
    /**
     * 导出学生数据到CSV文件
     */
    public void exportStudents(List<Student> students, String csvFile) throws IOException {
        try (PrintWriter writer = new PrintWriter(new FileWriter(csvFile, StandardCharsets.UTF_8))) {
            // 写入CSV头部
            writer.println("学号,姓名,年龄,专业,入学日期,GPA");
            
            // 写入学生数据
            for (Student student : students) {
                String line = String.format("\"%s\",\"%s\",%d,\"%s\",\"%s\",%.2f",
                    student.getStudentId(),
                    student.getName(),
                    student.getAge(),
                    student.getMajor(),
                    student.getEnrollmentDate(),
                    student.getGpa()
                );
                writer.println(line);
            }
        }
    }
}

// ==================== CSV导入器类 ====================

/**
 * CSV导入器类
 * 负责从CSV文件导入学生数据
 */
class CSVImporter {
    
    /**
     * 从CSV文件导入学生数据
     */
    public List<Student> importStudents(String csvFile) throws IOException {
        List<Student> students = new ArrayList<>();
        
        try (BufferedReader reader = new BufferedReader(new FileReader(csvFile, StandardCharsets.UTF_8))) {
            String line;
            boolean firstLine = true;
            
            while ((line = reader.readLine()) != null) {
                if (firstLine) {
                    firstLine = false; // 跳过头部
                    continue;
                }
                
                // 简单的CSV解析（实际项目中应使用专门的CSV库）
                String[] parts = parseCSVLine(line);
                if (parts.length >= 6) {
                    try {
                        Student student = new Student(
                            parts[0], // 学号
                            parts[1], // 姓名
                            Integer.parseInt(parts[2]), // 年龄
                            parts[3], // 专业
                            java.time.LocalDate.parse(parts[4]), // 入学日期
                            Double.parseDouble(parts[5]) // GPA
                        );
                        students.add(student);
                    } catch (Exception e) {
                        System.err.println("解析学生数据失败: " + line + ", 错误: " + e.getMessage());
                    }
                }
            }
        }
        
        return students;
    }
    
    /**
     * 简单的CSV行解析
     */
    private String[] parseCSVLine(String line) {
        // 这是一个简化的CSV解析器，实际项目中应使用专门的库
        return line.split(",(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");
    }
}

// ==================== ZIP压缩器类 ====================

/**
 * ZIP压缩器类
 * 负责文件的压缩和解压
 */
class ZipCompressor {
    
    /**
     * 压缩单个文件
     */
    public static void compressFile(String sourceFile, String zipFile) throws IOException {
        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile))) {
            File file = new File(sourceFile);
            ZipEntry entry = new ZipEntry(file.getName());
            zos.putNextEntry(entry);
            
            try (FileInputStream fis = new FileInputStream(file)) {
                byte[] buffer = new byte[1024];
                int bytesRead;
                while ((bytesRead = fis.read(buffer)) != -1) {
                    zos.write(buffer, 0, bytesRead);
                }
            }
        }
    }
    
    /**
     * 压缩目录
     */
    public static void compressDirectory(String sourceDir, String zipFile) throws IOException {
        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile))) {
            File dir = new File(sourceDir);
            compressDirectoryRecursive(dir, dir.getName(), zos);
        }
    }
    
    /**
     * 递归压缩目录
     */
    private static void compressDirectoryRecursive(File dir, String basePath, ZipOutputStream zos) throws IOException {
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                String entryPath = basePath + "/" + file.getName();
                
                if (file.isDirectory()) {
                    compressDirectoryRecursive(file, entryPath, zos);
                } else {
                    ZipEntry entry = new ZipEntry(entryPath);
                    zos.putNextEntry(entry);
                    
                    try (FileInputStream fis = new FileInputStream(file)) {
                        byte[] buffer = new byte[1024];
                        int bytesRead;
                        while ((bytesRead = fis.read(buffer)) != -1) {
                            zos.write(buffer, 0, bytesRead);
                        }
                    }
                }
            }
        }
    }
    
    /**
     * 解压ZIP文件
     */
    public static void extractZip(String zipFile, String extractDir) throws IOException {
        try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile))) {
            ZipEntry entry;
            while ((entry = zis.getNextEntry()) != null) {
                File file = new File(extractDir, entry.getName());
                
                if (entry.isDirectory()) {
                    file.mkdirs();
                } else {
                    file.getParentFile().mkdirs();
                    
                    try (FileOutputStream fos = new FileOutputStream(file)) {
                        byte[] buffer = new byte[1024];
                        int bytesRead;
                        while ((bytesRead = zis.read(buffer)) != -1) {
                            fos.write(buffer, 0, bytesRead);
                        }
                    }
                }
                zis.closeEntry();
            }
        }
    }
    
    /**
     * 列出ZIP文件内容
     */
    public static void listZipContents(String zipFile) throws IOException {
        try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile))) {
            ZipEntry entry;
            while ((entry = zis.getNextEntry()) != null) {
                System.out.println("  " + entry.getName() + 
                                 " (大小: " + entry.getSize() + " 字节)");
                zis.closeEntry();
            }
        }
    }
}

// ==================== 批量文件处理器类 ====================

/**
 * 批量文件处理器类
 * 负责批量文件操作
 */
class BatchFileProcessor {
    
    /**
     * 批量重命名文件
     */
    public static void renameFiles(String dirPath, String oldPrefix, String newPrefix) throws IOException {
        File dir = new File(dirPath);
        File[] files = dir.listFiles();
        
        if (files != null) {
            for (File file : files) {
                if (file.isFile() && file.getName().startsWith(oldPrefix)) {
                    String newName = file.getName().replace(oldPrefix, newPrefix);
                    File newFile = new File(dir, newName);
                    if (file.renameTo(newFile)) {
                        System.out.println("重命名: " + file.getName() + " -> " + newName);
                    }
                }
            }
        }
    }
    
    /**
     * 批量移动文件
     */
    public static void moveFiles(String sourceDir, String targetDir, String pattern) throws IOException {
        File source = new File(sourceDir);
        File target = new File(targetDir);
        target.mkdirs();
        
        File[] files = source.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isFile() && file.getName().matches(pattern.replace("*", ".*"))) {
                    File targetFile = new File(target, file.getName());
                    if (file.renameTo(targetFile)) {
                        System.out.println("移动: " + file.getName() + " -> " + targetDir);
                    }
                }
            }
        }
    }
    
    /**
     * 批量内容替换
     */
    public static void replaceContent(String dirPath, String oldText, String newText) throws IOException {
        File dir = new File(dirPath);
        File[] files = dir.listFiles();
        
        if (files != null) {
            for (File file : files) {
                if (file.isFile() && file.getName().endsWith(".txt")) {
                    replaceFileContent(file, oldText, newText);
                }
            }
        }
    }
    
    /**
     * 替换文件内容
     */
    private static void replaceFileContent(File file, String oldText, String newText) throws IOException {
        Path path = file.toPath();
        String content = Files.readString(path, StandardCharsets.UTF_8);
        String newContent = content.replace(oldText, newText);
        Files.writeString(path, newContent, StandardCharsets.UTF_8);
        System.out.println("内容替换: " + file.getName());
    }
}

// ==================== 网络数据包类 ====================

/**
 * 网络数据包类
 * 模拟网络传输的数据包
 */
class NetworkPacket implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private int id;
    private String type;
    private String payload;
    private long timestamp;
    
    // getter和setter方法
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    
    public String getType() { return type; }
    public void setType(String type) { this.type = type; }
    
    public String getPayload() { return payload; }
    public void setPayload(String payload) { this.payload = payload; }
    
    public long getTimestamp() { return timestamp; }
    public void setTimestamp(long timestamp) { this.timestamp = timestamp; }
}

// ==================== 网络数据序列化器类 ====================

/**
 * 网络数据序列化器类
 * 负责网络数据包的序列化和反序列化
 */
class NetworkDataSerializer {
    
    /**
     * 序列化数据包
     */
    public static void serializePacket(NetworkPacket packet, String file) throws IOException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {
            oos.writeObject(packet);
        }
    }
    
    /**
     * 反序列化数据包
     */
    public static NetworkPacket deserializePacket(String file) throws IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
            return (NetworkPacket) ois.readObject();
        }
    }
}

// ==================== 网络数据模拟器类 ====================

/**
 * 网络数据模拟器类
 * 模拟网络数据传输过程
 */
class NetworkDataSimulator {
    
    /**
     * 模拟数据传输
     */
    public void simulateDataTransfer(NetworkPacket packet) {
        System.out.println("模拟网络数据传输:");
        System.out.println("  发送数据包 ID: " + packet.getId());
        System.out.println("  数据包类型: " + packet.getType());
        System.out.println("  数据包大小: " + packet.getPayload().getBytes().length + " 字节");
        System.out.println("  传输状态: 成功");
        System.out.println("  传输时间: " + new Date(packet.getTimestamp()));
    }
} 